This case is about a bank (Thera Bank) which has a growing customer base. Majority of these customers are liability customers (depositors) with varying size of deposits. The number of customers who are also borrowers (asset customers) is quite small, and the bank is interested in expanding this base rapidly to bring in more loan business and in the process, earn more through the interest on loans. In particular, the management wants to explore ways of converting its liability customers to personal loan customers (while retaining them as depositors). A campaign that the bank ran last year for liability customers showed a healthy conversion rate of over 9% success. This has encouraged the retail marketing department to devise campaigns with better target marketing to increase the success ratio with minimal budget.
Problem Statement:¶
The department wants to build a model that will help them identify the potential customers who have higher probability of purchasing the loan. This will increase the success ratio while at the same time reduce the cost of the campaign. The data file contains data on 5000 customers. The data include customer demographic information (age, income, etc.), the customer's relationship with the bank (mortgage, securities account, etc.), and the customer response to the last personal loan campaign (Personal Loan). Among these 5000 customers, only 480 (= 9.6%) accepted the personal loan that was offered to them in the earlier campaign.
Objective:¶
The classification goal is to predict the likelihood of a liability customer buying personal loans.
Data Description:¶
- 1.ID:Customer ID
- 2.Age:Customer's age in completed years
- 3.Experience: Years of professional experience
- 4.Income: Annual income of the customer (In USD).
- 5.ZIPCode: Home Address ZIP code.
- 6.Family: Family size of the customer
- 7.CCAvg: Avg spending on credit cards per month (In USD)
- 8.Education: Education Level- 1: Undergrad; 2: Graduate; 3: Advanced/Professional
- 9.Mortgage: Value of house mortgage if any. (In USD)
- 10.Personal Loan: Did this customer accept the personal loan offered in the last campaign?
- 11.Securities Account: Does the customer have a securities account with the bank?
- 12.CD Account: Does the customer have a certificate of deposit (CD) account with the bank?
- 13.Online: Does the customer use internet banking facilities?
- 14.CreditCard: Does the customer use a credit card issued by UniversalBank?
In [1]:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline
import seaborn as sns
In [2]:
df=pd.read_csv(r'C:\Users\$ubhajit\Downloads\Bank_Personal_Loan_Modelling-1.csv')
#Making a copy of the dataset.
df_copy=df.copy()
In [3]:
df.columns
Out[3]:
In [4]:
#replacing spaces with an underscore and return lower case text
df.columns = [i.replace(' ', '_').lower() for i in df.columns]
df.columns
Out[4]:
Dataset Size¶
In [5]:
df.shape
Out[5]:
There are 5000 rows and 14 columns in the dataset.
In [6]:
df.info()
In [7]:
df.head()
Out[7]:
In [8]:
df.tail()
Out[8]:
In [9]:
loans_counts=df['personal_loan'].value_counts().to_frame()
loans_counts
Out[9]:
In [10]:
df.describe().T
Out[10]:
In [11]:
df.nunique()
Out[11]:
In [12]:
features = ['age', 'experience', 'family','income']
df[features].hist(figsize=(12, 8))
Out[12]:
Univariate Analysis:¶
In [13]:
#!pip install pandas_profiling
In [14]:
import pandas_profiling
df.profile_report()
Out[14]:
- Click on Toggle details to see more analysis.
Points observed by profile report & univariate analysis:¶
- The data set got 0 missing cells.
- It got 7 numeric variables: ‘age’, ‘cc_avg’, ‘id’, ‘income’, ‘mortgage’, ‘zip_code’, ‘experience’
- It got 2 categorical variables: ‘education’, ‘family’
- It got 5 Boolean variables: ‘cd_account’, ‘credit_card’, ‘online’, ‘personal_loan’, ‘securities_account’
- Personal Loan is highly correlated with Income, average spending on Credit cards, mortgage & if the customer has a certificate of deposit (cd) account with the bank.
- Also, Experience is highly correlated with Age.
- 42% of the candidates are graduated, while 30% are professional and 28% are Undergraduate.
- Around 29% of the customer’s family size is 1.
- 94% of the customer doesn’t have a certificate of deposit (cd) account with the bank.
- Around 71% of the customer doesn’t use a credit card issued by UniversalBank.
- Around 60% of customers use internet banking facilities.
- Around 90% of the customer doesn’t accept the personal loan offered in the last campaign.
- Around 90% of the customer doesn’t have a securities account with the bank.
- The mean age of the customers is 45 with standard deviation of 11.5. Also, we had estimated the average age in hypothesis testing between 30–50. The curve is slightly negatively skewed (Skewness = -0.02934068151) hence the curve is fairly symmetrical
- The mean of Avg. spending on credit cards per month is 1.93 with standard deviation of 1.75. The curve is highly positive skewed (Skewness = 1.598443337)
- The mean annual income of the customer is 73.77 with standard deviation of 46. The curve is moderately positive skewed (Skewness = 0.8413386073)
- The mean value of house mortgage is 56.5 with standard deviation of 101.71. The curve is highly positive skewed (Skewness = 2.104002319) and there are a lot of outlier’s present (Kurtosis = 4.756796669)
In [15]:
#Dropping 'ID' and 'ZIP Code' as they are just numbers of series
df.drop('id',axis=1,inplace=True)
df.drop('zip_code',axis=1,inplace=True)
Bivariate Analysis:¶
In [16]:
df_edu=pd.crosstab(df['education'],df['personal_loan'])
df_edu.div(df_edu.sum(1).astype(float),axis=0).plot(kind='bar', stacked=True)
print('Cross tabulation can be given as:','\n',df_edu)
print('Cross tabulation in percentages:','\n',df_edu.div(df_edu.sum(1).astype(float),axis=0))
- From the above plots, we can infer that customers who are more educated have a higher probability of buying personal loans.
In [17]:
df_family=pd.crosstab(df['family'],df['personal_loan'])
df_family.div(df_family.sum(1).astype(float),axis=0).plot(kind='bar', stacked=True)
print('Cross tabulation can be given as:','\n',df_family)
print('Cross tabulation in percentages:','\n',df_family.div(df_family.sum(1).astype(float),axis=0))
- The number of family members not significantly affect probability.
In [18]:
df_cd=pd.crosstab(df['cd_account'],df['personal_loan'])
df_cd.div(df_cd.sum(1).astype(float),axis=0).plot(kind='bar', stacked=True)
print('Cross tabulation can be given as:','\n',df_cd)
print('Cross tabulation in percentages:','\n',df_cd.div(df_cd.sum(1).astype(float),axis=0))
- The customer who has a certificate of deposit (CD) account with the bank seems to buy personal loans from the bank.
In [19]:
df_credit=pd.crosstab(df['creditcard'],df['personal_loan'])
df_credit.div(df_credit.sum(1).astype(float),axis=0).plot(kind='bar', stacked=True)
print('Cross tabulation can be given as:','\n',df_credit)
print('Cross tabulation in percentages:','\n',df_credit.div(df_credit.sum(1).astype(float),axis=0))
- The customer who uses or doesn’t use a credit card issued by Bank doesn’t seem to affect the probability of buying a personal loan.
In [20]:
df_online=pd.crosstab(df['online'],df['personal_loan'])
df_online.div(df_online.sum(1).astype(float),axis=0).plot(kind='bar', stacked=True)
print('Cross tabulation can be given as:','\n',df_online)
print('Cross tabulation in percentages:','\n',df_online.div(df_online.sum(1).astype(float),axis=0))
- The customer who uses or doesn’t use internet banking facilities seems to not affect the probability of buying personal loans.
In [21]:
df_securities=pd.crosstab(df['securities_account'],df['personal_loan'])
df_securities.div(df_securities.sum(1).astype(float),axis=0).plot(kind='bar', stacked=True)
print('Cross tabulation can be given as:','\n',df_securities)
print('Cross tabulation in percentages:','\n',df_securities.div(df_securities.sum(1).astype(float),axis=0))
- The customers who have or don’t have securities account with the bank do not affect the probability of buying a personal loan.
In [22]:
df.groupby('personal_loan')['ccavg'].mean().plot(kind='bar')
Out[22]:
- Here the y-axis represents the mean applicant spending on credit cards per month ('$000'). It can be clearly seen that applicants who spend more on credit cards are more viable to buy personal loans.
In [23]:
df.groupby('personal_loan')['income'].mean().plot(kind='bar')
Out[23]:
- Here the y-axis represents the mean annual income of the customer ($000). It can be clearly seen that the customers with high incomes are more feasible to buy the personal loan.
In [24]:
df.groupby('personal_loan')['experience'].mean().plot(kind='bar')
Out[24]:
- The customers who have or don’t have experiences do not affect the probability of buying a personal loan.
Missing Value and Outlier Treatment:¶
In [25]:
#rechecking missing value:
df.isnull().sum()
Out[25]:
Outlier Treatment:¶
As we saw earlier in univariate analysis, Mortgage contains outliers, so I must treat them as the presence of outliers affects the distribution of the data.Due to these outliers’ bulk of the data in the Mortgage is Right Skewed.One way to remove the skewness is by doing the z-score.
In [26]:
# importing Z-score from stst library.
from scipy import stats
df['Mortgage_Zscore']=np.abs(stats.zscore(df['mortgage']))
df=df[df['Mortgage_Zscore']<3]
df.drop('Mortgage_Zscore',axis=1,inplace=True)
In [27]:
df.shape
Out[27]:
Here I had chosen those rows only whose z_score is less than 3, it can vary accordingly. Here I had dropped more than 100+ rows which contain outliers and now I can start with the model building.
Model Building: Logistic Regression¶
In [28]:
#Importing library for spliting data
from sklearn.model_selection import train_test_split
#Importing model
from sklearn.linear_model import LogisticRegression
#Importing library to check accuracy_score
from sklearn.metrics import accuracy_score
from sklearn.metrics import classification_report
from sklearn.metrics import confusion_matrix
from sklearn.metrics import roc_curve,auc
Spliting of the data in the ratio of 70:30 respectively¶
In [29]:
# set of independent variable
X=df.drop('personal_loan',axis=1)
# set of dependent variable
y=df['personal_loan']
#Spliting of the data in the ratio of 70:30 respectively
X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.30,random_state=1)
Standardising and normalising the data:¶
In [30]:
#Importing libraries
from sklearn import preprocessing
#Get column names
column_name= df.columns
#Create scaler object
scaler=preprocessing.StandardScaler()
#Fit data on the scaler object
scaled_X_train=scaler.fit_transform(X_train)
scaled_X_test=scaler.fit_transform(X_test)
In [31]:
scaled_X_train
Out[31]:
In [32]:
scaled_X_test
Out[32]:
In [33]:
#normalize the data attributes
normalized_X = preprocessing.normalize(X)
In [34]:
logreg=LogisticRegression()
#Fitting the model into training dataset
logreg.fit(scaled_X_train,y_train)
Out[34]:
In [35]:
y_pred=logreg.predict(scaled_X_test)
In [36]:
print(classification_report(y_test,y_pred))
In [37]:
print(accuracy_score(y_test,y_pred))
In [38]:
print(confusion_matrix(y_test,y_pred))
So, we can see 95% accuracy by applying logistic regression model.
In [39]:
from sklearn.metrics import roc_auc_score
from sklearn.metrics import roc_curve
In [40]:
logreg_prob=logreg.predict_proba(scaled_X_test)
fpr,tpr,threshold=roc_curve(y_test,logreg_prob[:,1])
roc_auc=auc(fpr,tpr)
print('Area under the ROC curve :%f'%roc_auc)
The area under ROC curve got 95% accuracy.
In [41]:
plt.figure()
plt.plot(fpr, tpr, label='Logistic Regression (area = %f)' % roc_auc)
plt.plot([0, 1], [0, 1],'r--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver operating characteristic')
plt.legend(loc="lower right")
plt.savefig('Log_ROC')
plt.show()
The dotted line represents the ROC curve of a purely random classifier.
Decision Tree:¶
Let us see if the decision tree with criterion as entropy can nail it down to higher recall value or with criterion as gini.
In [42]:
from sklearn.tree import DecisionTreeClassifier
dec_treeE=DecisionTreeClassifier(criterion='entropy',random_state=1)
dec_treeE.fit(scaled_X_train,y_train)
y_pred=dec_treeE.predict(scaled_X_test)
In [43]:
print(classification_report(y_test,y_pred))
In [44]:
print(accuracy_score(y_test,y_pred))
In [45]:
print(confusion_matrix(y_test,y_pred))
In [46]:
dec_treeE_prob=dec_treeE.predict_proba(scaled_X_test)
fpr1,tpr1,threshold1=roc_curve(y_test,dec_treeE_prob[:,1])
roc_auc1=auc(fpr1,tpr1)
print('Area under the ROC curve :%f'%roc_auc1)
- We got a 98% accuracy score while 91% recall value.
In [47]:
plt.figure()
plt.plot(fpr1, tpr1, label='Decision Tree Entropy(area = %f)' % roc_auc1)
plt.plot([0, 1], [0, 1],'r--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver operating characteristic')
plt.legend(loc="lower right")
plt.savefig('Log_ROC')
plt.show()
In [48]:
from sklearn.tree import DecisionTreeClassifier
dec_treeG=DecisionTreeClassifier(criterion='gini',random_state=1)
dec_treeG.fit(scaled_X_train,y_train)
y_pred=dec_treeG.predict(scaled_X_test)
In [49]:
print(classification_report(y_test,y_pred))
In [50]:
print(accuracy_score(y_test,y_pred))
In [51]:
print(confusion_matrix(y_test,y_pred))
In [52]:
dec_treeG_prob=dec_treeG.predict_proba(scaled_X_test)
fpr2,tpr2,threshold2=roc_curve(y_test,dec_treeG_prob[:,1])
roc_auc2=auc(fpr2,tpr2)
print('Area under the ROC curve :%f'%roc_auc2)
- We got a 97% accuracy score while an astonishing 88% recall value.
In [53]:
plt.figure()
plt.plot(fpr2, tpr2, label='Decision Tree GINI(area = %f)' % roc_auc2)
plt.plot([0, 1], [0, 1],'r--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver operating characteristic')
plt.legend(loc="lower right")
plt.savefig('Log_ROC')
plt.show()
The area under the ROC curve is much smaller in this case too. The reason being the ‘overfitting’ of the data. Let us check the accuracy score for training as well as test data.
In [54]:
print(dec_treeE.score(scaled_X_train,y_train))
In [55]:
print(dec_treeG.score(scaled_X_train,y_train))
Now we will use Hyperparameter prunning to generalise the overfitting of data.
In [56]:
from sklearn.tree import DecisionTreeClassifier
dec_tree_prunE=DecisionTreeClassifier(criterion='entropy',max_depth=4,min_samples_leaf=7,random_state=2)
dec_tree_prunE.fit(scaled_X_train,y_train)
y_pred=dec_tree_prunE.predict(scaled_X_test)
In [57]:
print(classification_report(y_test,y_pred))
In [58]:
print(accuracy_score(y_test,y_pred))
In [59]:
print(confusion_matrix(y_test,y_pred))
In [60]:
dec_tree_prunE_prob=dec_tree_prunE.predict_proba(scaled_X_test)
fpr3,tpr3,threshold3=roc_curve(y_test,dec_tree_prunE_prob[:,1])
roc_auc3=auc(fpr3,tpr3)
print('Area under the ROC curve :%f'%roc_auc3)
We can see the difference now. We got 98% accuracy with 88% recall value, also the AUC is 99% which is fairly good. Let us check the same for the criterion ‘Gini’ then we can conclude to the results of decision trees.
In [61]:
from sklearn.tree import DecisionTreeClassifier
dec_tree_prunG=DecisionTreeClassifier(criterion='gini',max_depth=4,min_samples_leaf=7,random_state=2)
dec_tree_prunG.fit(scaled_X_train,y_train)
y_pred=dec_tree_prunG.predict(scaled_X_test)
In [62]:
print(classification_report(y_test,y_pred))
In [63]:
print(accuracy_score(y_test,y_pred))
In [64]:
print(confusion_matrix(y_test,y_pred))
In [65]:
dec_tree_prunG_prob=dec_tree_prunG.predict_proba(scaled_X_test)
fpr3,tpr3,threshold3=roc_curve(y_test,dec_tree_prunG_prob[:,1])
roc_auc3=auc(fpr3,tpr3)
print('Area under the ROC curve :%f'%roc_auc3)
We got 83% recall value with a 97% accuracy level, also AUC is approximately 98% which is also fairly good.
Naive Bayes:¶
In [66]:
from sklearn.naive_bayes import GaussianNB
naive_model=GaussianNB()
naive_model.fit(scaled_X_train,y_train)
y_pred=naive_model.predict(scaled_X_test)
In [67]:
print(classification_report(y_test,y_pred))
In [68]:
print(accuracy_score(y_test,y_pred))
In [69]:
print(confusion_matrix(y_test,y_pred))
In [70]:
naive_model_prob=naive_model.predict_proba(scaled_X_test)
fpr4,tpr4,threshold4=roc_curve(y_test,naive_model_prob[:,1])
roc_auc4=auc(fpr4,tpr4)
print('Area under the ROC curve :%f'%roc_auc4)
We got 59% recall value with a 89% accuracy level, also AUC is approximately 92%.
Which is the best model in this case:¶
The Decision Tree model is the best as the accuracy of the train and test set is almost similar and also the precsion and recall accuracy is good. The confusion matrix is also better in comparision to Logistic Regression and Naive Bayes model. Naive bayes has very low performance in this case.